/**
* 说明：数据组件类定义
Widget class 说明 ：
	2.0 构造函数：Widget(widgetName,defString)
		对于通过组合得到的新类型，进行管理
	2.1 widget 名字:getName()
	2.2 得到原始定义json:getDefString();getDefJson()
	2.3 得到metameta定义信息: getMetaMetaDef()，需要深度clone原始定义;
	2.4 从传入的validation信息获得meta（json schema） 定义信息: getMetaDef(validationDef)
**/

(function(){
//页面元数据对象，注册到window中，全局可用

	var WidgetClass = function(widgetName,defString){
		this.name = widgetName;
		this.json = defString;

		this.jsonObj = JSON.parse(defString);


		//cache obj
		this.metaMetaDef = null;
	};

	WidgetClass.prototype = {

		//初始化类型信息，便于后续提供类型定义信息
		init:function(){
			if(!this.metaMetaDef)
				this.getMetaMetaDef();
			return true;
		},
		//得到对象名
		getName:function() {return this.name;},
		//得到json原始定义信息，json字符串形式
		getDefJson:function() {return this.json;},

		/**
		** 得到类型的metameta定义，返回形式是json对象
		** parameter：
		//得到元元模型定义信息
		//注意：得到的模型是类型定义，全局有效，如果实例化需要进行clone
		**/
		getMetaMetaDef:function(){
			if(this.metaMetaDef) return this.metaMetaDef;
			//初始化元元模型信息

			var propertyJson = JSON.parse(this.json);
			//滤除数据定义部分
			var props = propertyJson['properties'];
			//逐项处理属性信息：不是内置类型，是派生类型或json内置类型
			for(var prp in props){
				if(! props[prp]) continue;
				var type = props[prp]['type'];
				if(type && pagemeta.extTypes.hasOwnProperty(type)){	//是内置类型，需要递归装载定义
					var title = props[prp]['title'];
					var clz = pagemeta.getWidgetCloneDef(type,props[prp]);
					if(title)	clz.metaMetaDef['title'] = title;
					props[prp] = clz.metaMetaDef;
				}
				else{
					if(type === 'object'){
						var metatmp = buildObject(props[prp]);
						props[prp] = metatmp;
					}
				}
				//else if(pagemeta.isJSONBuildin(type)){ 	//是json内置类型，直接输出

			}
			if(props['__wrappedType'] && props['__wrappedType']['__validationRule'] ){	//是原始类型封装
					var rules = props['__wrappedType']['__validationRule'];
					deepCopy(props,rules);
					//delete SCHEMA_DEF_MARK node
					 props['__wrappedType'] = undefined;
			}


			this.metaMetaDef = propertyJson;
			return this.metaMetaDef;
		}
	};

	/**
	**	根据出入的参数，获得元模型定义json对象，为deepCopy json
		getMetaDef:function(metaParam,metaDef){
			var ret = {};
			//滤除数据定义部分
			var props = this.jsonObj['properties'];
			//是原始类型封装？
			if(props['__wrappedType']){
				for(var p in props['__wrappedType']){
					ret[p] = {};
					if(p['__validationRule']){	// 存在json校验条件定义
						for(var vp in p['__validationRule']){
							ret[p][vp] = metaParam[vp];
						}
					}
					else{
						ret[p] = props['__wrappedType'][p];
					}
				}
			}
			else{	//是自定义类型，递归处理；
				for(var p in this.jsonObj){
					if(p === "properties"){
						ret[p]={};
						for(var sp in this.jsonObj[p]){
							var type = sp['type'];
							if(type && pagemeta.extTypes.hasOwnProperty(type)){	//是内置类型，需要递归装载定义
								if(type === "TArrayDef"){//如果是数组类型，需要扩展它的items对象定义
									var items = props[prp]['items'];
									if(items)
										clz['properties']['items'] = buildObject(items);
								}
								else
									ret[p][sp] = pagemeta.initComponent(type).getMetaDef(metaParam[sp])；
							}
							else{
								//会出现这种情况吗？
							}
						}
					}
					else
						ret[p] = this.jsonObj[p];
				}
			}

			return ret;
		}
	};

	**/

	window.widget = WidgetClass;
})();
